#ifndef __CLAVEESPACIOLIBRE_H__
#define __CLAVEESPACIOLIBRE_H__


#include "Tipos.h"

/**********************ESTRUCTURA DEL ARCHIVO ********************/
/*	#REGISTROS NROBLOQUE_SIG  NRO_BLOQUES......						 */
/*****************************************************************/
/******EL INDICE*********/
/*
CLAVE #INDICE_VECTOR  VECTOR[]  (el ultimo item indica el bloque siguiente)
*/

class CClaveEspacioLibre
{
private:
	void insertarOrdenado(string dato, string nroBloque);
	void ordenar();
public:
	TIPO_DATO m_clave; //este es el tama�o en byte de espacios libres que tiene cada uno de los bloques que se tiene en el vector
	vector<TIPO_DATO> m_nroBloques;//Lista de bloques
	int m_indice;
	TIPO_DATO m_nroBloque;

	CClaveEspacioLibre(TIPO_DATO espacio,TIPO_DATO nroBloque);
	CClaveEspacioLibre(){}
	~CClaveEspacioLibre(){}
	//trasformar(char &dato[]) //con todo el char
	TIPO_DATO getCodProducto(){return m_nroBloque;}
	TIPO_DATO getCodProducto(int indice){return m_nroBloques[indice];}
	TIPO_DATO getCodProd(int indice);
	TIPO_DATO getTamanio(){return (TIPO_DATO)(TAMANIO_COD_PROD + TAMANIO_COD_PROD + TAMANIO_COD_PROD*CANT_CODIGOS);}	
	TIPO_DATO getTamanioNodo(){return (TIPO_DATO)(TAMANIO_COD_PROD );}	
	bool obtenerNroBloque(TIPO_DATO &nroBloqueOut,fstream &archivo);
	TIPO_DATO getClave(){return m_clave;}
	int getIndice(){return m_indice;}
	void setIndice(int indice){m_indice =indice;}
	void setClave(TIPO_DATO clave){m_clave =clave;}
	void setNroBloque(TIPO_DATO nrobloque){m_nroBloques[0]=nrobloque;}
	int transformar(string datos, TIPO_DATO &pos);
	string desTransformar();
	int transformarNodo(string datos, TIPO_DATO &pos);
	string desTransformarNodo();
	void mostrar(void);
	void insertarVectorSec(TIPO_DATO codProdIn,fstream &archivo);
	bool eliminarElemVector(TIPO_DATO claveIn,fstream &archivo);
	//OPERADORES
	CClaveEspacioLibre &operator=(CClaveEspacioLibre & clave);
	bool operator==(CClaveEspacioLibre &clave) const;
	bool operator<(CClaveEspacioLibre &clave) const;	
	
	//FIN DE OPERADORES
/*    bool operator()(CClaveEspacioLibre& inicio, CClaveEspacioLibre& fin)
    {
    	if(inicio.getClave().compare(fin.getClave()))
    		return true;
    	return false;
    }
	*/
};

/*-----------------------------------------------------------*/
CClaveEspacioLibre::CClaveEspacioLibre(TIPO_DATO espacio,TIPO_DATO nroBloque)
{
	this->m_clave = espacio;
	this->m_nroBloques.push_back(nroBloque);
	this->m_indice=1;
}
/*-----------------------------------------------------------*/
void CClaveEspacioLibre::mostrar(void)
{				
	cout<<"Tamanio de espacio libres: "<<m_clave<<endl;	
	cout<<"Se encuentra en los bloques: "<<endl;	
	for(int i=0;i<m_indice;i++)	
		cout<<i<<" .-) "<<this->m_nroBloques[i]<<endl;
	cout<<endl;
}
/*-----------------------------------------------------------*/
int CClaveEspacioLibre::transformar(string datos, TIPO_DATO &posicion)
{	
	int i;	
	m_clave =  string2TipoDato(datos.substr(posicion,TAMANIO_COD_PROD));
	posicion+=TAMANIO_COD_PROD;
	m_indice =string2TipoDato(datos.substr(posicion,TAMANIO_BYTE_LISTA));
	posicion+=TAMANIO_BYTE_LISTA;
	for(i=0;i<m_indice;i++)
	{
		m_nroBloques.push_back(string2TipoDato(datos.substr(posicion,TAMANIO_COD_PROD)));
		posicion+= TAMANIO_COD_PROD;
	}
	//esto es porque el vector es estatico
	for(;i<CANT_CODIGOS;i++)
		posicion+= TAMANIO_COD_PROD;
	
	return TAMANIO_COD_PROD + TAMANIO_BYTE_LISTA +CANT_CODIGOS*TAMANIO_COD_PROD;
} 
/*-----------------------------------------------------------*/
string CClaveEspacioLibre::desTransformar()
{
	string dato="";
	TIPO_DATO testeo;
	int i;
	dato+=convertirChar(m_clave,TAMANIO_COD_PROD);
	if(m_indice==47)
		cout<<"Son demasiados"<<endl;
	dato+=convertirChar(m_indice,TAMANIO_BYTE_LISTA);
	for(i=0;i<m_indice;i++)	
	{
		testeo = m_nroBloques[i];
		//dato+=itoa(codProductos[m_indice],numero,10);
		dato+=convertirChar(m_nroBloques[i],TAMANIO_COD_PROD);
	}
	for(;i<CANT_CODIGOS;i++)
		dato+="0000";	
	return dato;
}
/*-----------------------------------------------------------*/
int CClaveEspacioLibre::transformarNodo(string datos, TIPO_DATO &posicion)
{	
	m_clave =  string2TipoDato(datos.substr(posicion,TAMANIO_COD_PROD));
	m_indice=0;
	posicion+=TAMANIO_COD_PROD;	
	return TAMANIO_COD_PROD ;
} 
/*-----------------------------------------------------------*/
string CClaveEspacioLibre::desTransformarNodo()
{
	string dato="";
	dato+=convertirChar(m_clave,TAMANIO_COD_PROD);
	return dato;
}
/*-----------------------------------------------------------*/

CClaveEspacioLibre &CClaveEspacioLibre::operator=(CClaveEspacioLibre & key)
{
	if(this==&key)
		return *this;
	this->m_clave = key.getClave();
	this->m_indice =key.getIndice();
	this->m_nroBloques.clear();
	for(int i=0;i<this->m_indice ;i++)	
		this->m_nroBloques.push_back( key.getCodProducto(i));
	return *this;	
}
/*-----------------------------------------------------------*/
bool CClaveEspacioLibre::operator==(CClaveEspacioLibre &key)const
{
	return m_clave == key.getClave();
}
/*-----------------------------------------------------------*/
bool CClaveEspacioLibre::operator<(CClaveEspacioLibre &key) const
{
	return m_clave < key.getClave();
}
/*-----------------------------------------------------------*/

//VER SI PUEDE ENTRAR UN REGISTRO CON EL MISMO ID !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
void CClaveEspacioLibre::insertarVectorSec(TIPO_DATO nroBloqueIn,fstream &archivo)
{
	char bloque[TAMANIO_LISTA_COD]={};
	string dato="";
	TIPO_DATO cantMaxCod;
	TIPO_DATO nroBloqueAux;

	if(this->m_indice==(CANT_CODIGOS))
	{
		//escribir en el archivo de listados
		TIPO_DATO blAux;		

		//el ultimo registro se guarda para concatenar los distintos bloques para formar la lista de codigos
		cantMaxCod = (TAMANIO_LISTA_COD-1)/TAMANIO_COD_PROD ;//cant max de codigos en el bloque de lista
		for(int i=0;i<(m_indice-1) ;i++)
		{
			if(m_nroBloques[i]>nroBloqueIn)
			{
				//fin=true;
				blAux=m_nroBloques[i];
				m_nroBloques[i] = nroBloqueIn;
				nroBloqueIn = blAux;
			}
		}

		nroBloqueAux = m_nroBloques[m_indice-1];
		archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
		archivo.read(bloque,TAMANIO_LISTA_COD);		
		while(cantMaxCod==((TIPO_DATO)(bloque[0])))
		{
			dato.append(bloque);
			nroBloqueAux = string2TipoDato(dato.substr(1,TAMANIO_COD_PROD));
			archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
			archivo.read(bloque,TAMANIO_LISTA_COD);
			dato="";
		}
		if((cantMaxCod-1)==((TIPO_DATO)(bloque[0])))
		{//es el ultimo lugar del vector
			TIPO_DATO tamanioArchivo,nroBloqueAuxSig;
			dato="";
			archivo.seekg(0, ios::end);	//se posiciona al final del archivo
			tamanioArchivo = archivo.tellg(); //indica en que pos del arch se encuentra (en byte)
			nroBloqueAuxSig =tamanioArchivo/TAMANIO_LISTA_COD;
			dato.replace(1,TAMANIO_COD_PROD,convertirChar(nroBloqueAuxSig,TAMANIO_COD_PROD));
			archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
			strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
			archivo.write(bloque,TAMANIO_LISTA_COD);

			//guardo en el nuevo bloque el nuevo codigo
			archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAuxSig ,ios::beg);
			
			dato=(unsigned char)1;
			dato+="0000";
			dato+=convertirChar(nroBloqueIn,TAMANIO_COD_PROD);
			strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
			archivo.write(bloque,TAMANIO_LISTA_COD);
			nroBloqueIn = nroBloqueAux ;
		}
		else
		{
		
			dato.append(bloque);
			
			int posicion=5;
			TIPO_DATO itemListaCod;
			for(int i=0; i<(int)dato[0];i++)
			{
				itemListaCod =string2TipoDato(dato.substr(posicion,TAMANIO_COD_PROD));
				
				if(itemListaCod>nroBloqueIn)
				{
					blAux=itemListaCod;
					dato.replace(posicion,TAMANIO_COD_PROD,convertirChar(nroBloqueIn,TAMANIO_COD_PROD));
					nroBloqueIn = blAux;
				}
				posicion+=TAMANIO_COD_PROD;
			}
			dato[0]++;
			dato+=convertirChar(nroBloqueIn,TAMANIO_COD_PROD);
			archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
			strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
			archivo.write(bloque,TAMANIO_LISTA_COD);

		}
		//dato+=convertirChar(codProdIn,TAMANIO_COD_PROD);
		//dato.replace(cantMaxCod*TAMANIO_COD_PROD+1,TAMANIO_COD_PROD,convertirChar(codProdIn,TAMANIO_COD_PROD));

	}
	else
	{
		if((CANT_CODIGOS-1)==m_indice)
		{//es el ultimo lugar del vector
			TIPO_DATO tamanioArchivo,testeo;
			vector<TIPO_DATO> superNodo;
			for(int i=0;i<m_indice;i++)
				superNodo.push_back(this->m_nroBloques[i]);
			superNodo.push_back(nroBloqueIn);
			std::sort(superNodo.begin(),superNodo.end());
			for(int i=0;i<=m_indice;i++)
				cout<<"DATOS DEL SUPERNODO>>>>"<<superNodo[i]<<endl;
			
			dato="";
			archivo.seekg(0, ios::end);	//se posiciona al final del archivo
			tamanioArchivo = archivo.tellg(); //indica en que pos del arch se encuentra (en byte)
			nroBloqueAux =tamanioArchivo/TAMANIO_LISTA_COD;
			archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
			for(int i=0;i<m_indice;i++)
				this->m_nroBloques[i]=superNodo[i];						
			for(int i=0;i<=m_indice;i++)
				cout<<"DATOS DEL NODO ORDENADOS>>>>"<<m_nroBloques[i]<<endl;

			this->m_nroBloques[this->m_indice++]=nroBloqueAux;
			//archivo.read(bloque,TAMANIO_LISTA_COD);
			dato=(unsigned char)1;
			dato+="0000";//nrobloque siguientes
			testeo =superNodo[this->m_indice-1];
			dato+=convertirChar(superNodo[this->m_indice-1],TAMANIO_COD_PROD);
			strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
			archivo.write(bloque,TAMANIO_LISTA_COD);
			nroBloqueIn = nroBloqueAux ;
		}
		else
		{
			vector<TIPO_DATO>::iterator		it;
//			TIPO_DATO codAux;
			this->m_nroBloques[this->m_indice++]=nroBloqueIn;
			std::sort(m_nroBloques.begin(),m_nroBloques.end(),::SortDesc());
			for(int i=0;i<m_indice;i++)
				cout<<"elemento del vector : "<<this->m_nroBloques[i]<<endl;
			ordenar();
			for(int i=0;i<m_indice;i++)
				cout<<"elemento del vector : "<<this->m_nroBloques[i]<<endl;

			
//			dato="";
//			dato[0]=(unsigned char)m_indice;
//			dato+=convertirChar((int)clave.length(),TAMANIO_BYTE_DIN);
//			dato+=this->clave;
//			for(int i=0;i<m_indice;i++)
//				dato+=convertirChar(this->codProductos[i],TAMANIO_COD_PROD);
//			strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
		}
	}
//	archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
//	archivo.write(bloque,TAMANIO_LISTA_COD);

}

TIPO_DATO CClaveEspacioLibre::getCodProd(int indice)
{
	return m_nroBloques[indice];
}
/*Cuando obtengo el codigo elimino el nro de bloque por que luego va a ser cambiado*/
bool CClaveEspacioLibre::obtenerNroBloque(TIPO_DATO &nroBloqueOut,fstream &archivo)
{
	if(this->m_indice==(CANT_CODIGOS))
	{//el proximo bloque esta en el archivo de bloques
		TIPO_DATO cantRegistros,cantMaxCod,nroBloqueAux;		
		string dato="";
		char bloque[TAMANIO_LISTA_COD]={};

		//el ultimo registro se guarda para concatenar los distintos bloques para formar la lista de codigos
		cantMaxCod = (TAMANIO_LISTA_COD-1)/TAMANIO_COD_PROD ;//cant max de codigos en el bloque de lista
		nroBloqueAux = m_nroBloques[m_indice-1];
		archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
		archivo.read(bloque,TAMANIO_LISTA_COD);		
		while(cantMaxCod==((TIPO_DATO)(bloque[0])))
		{
			dato.append(bloque);
			nroBloqueAux = string2TipoDato(dato.substr(1,TAMANIO_COD_PROD));
			archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
			archivo.read(bloque,TAMANIO_LISTA_COD);
			dato="";
		}
		dato.append(bloque);
		cantRegistros = (TIPO_DATO)(bloque[0]);
		nroBloqueOut = string2TipoDato(dato.substr(cantRegistros*TAMANIO_COD_PROD + TAMANIO_COD_PROD + 1,TAMANIO_COD_PROD));
		dato.replace(cantRegistros*TAMANIO_COD_PROD + TAMANIO_COD_PROD + 1,TAMANIO_COD_PROD,"");
		dato[0]--;
		strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
		archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
		archivo.write(bloque,TAMANIO_LISTA_COD);		

	}
	else
	{//el proximo bloque esta en la clave
		vector<TIPO_DATO>::iterator it;
		
		nroBloqueOut = m_nroBloques[m_indice-1];
//		if(m_indice==1)
		m_nroBloques.erase(m_nroBloques.begin()+(m_indice-1));
//		else		
//			m_nroBloques.erase(m_nroBloques.end());	
		
		--m_indice;
		if(m_indice==0)
			return false;
	}
	return true;
}
bool CClaveEspacioLibre::eliminarElemVector(TIPO_DATO nroBloqueIn,fstream &archivo)
{
	vector<TIPO_DATO>::iterator it;
	bool encontrada=false;//indica si encontro el nro de bloque en el vector
	//bool salir=false; //indica que no va a encontrar el nro bloque porque ya se encontro otro mas grande
	int contador=0;
	/*lo primero que hago es buscar en el vector si esta en el vector ten*/
	for(it = m_nroBloques.begin(); it!=m_nroBloques.end() && contador<(CANT_CODIGOS-1)&& !encontrada;it++)
	{	
		TIPO_DATO testeo;
		testeo =(*it);
		if((*it)==nroBloqueIn)
		{
			m_nroBloques.erase(m_nroBloques.begin() + contador);
			//m_indice--;
			if(this->m_indice != CANT_CODIGOS)
				m_indice--;
			encontrada=true;
			it = m_nroBloques.end();
		}
		++contador;
	}


	if(this->m_indice == CANT_CODIGOS)
	{
		if(encontrada)
		{//encontro la clave en el vector
			
			/*tengo que cargar el vector de claves con una clave de un bloque de no poder hacer esto se decrementa el vector*/
			/*una vez cargado el vector tengo que ir pasando los registros entre los bloques (como hice abajo)*/
			TIPO_DATO cantMaxCod,nroBloqueAux,bloqueAntiguo,cantBloquesRecorridos=0;
			int posicion,posAux;
			string dato="",strNroBloqueIn="",datoAux="";
			char bloque[TAMANIO_LISTA_COD]={};
			strNroBloqueIn = itoa((int)nroBloqueIn);
			//el ultimo registro se guarda para concatenar los distintos bloques para formar la lista de codigos
			cantMaxCod = (TAMANIO_LISTA_COD-1)/TAMANIO_COD_PROD ;//cant max de codigos en el bloque de lista
			nroBloqueAux = m_nroBloques[m_indice-1];
			archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
			archivo.read(bloque,TAMANIO_LISTA_COD);		
			dato.append(bloque);
			encontrada=false; //esto lo hago para reusar la variable
			/*comienzo a leer todos los bloques*/
			while(cantMaxCod==((TIPO_DATO)(bloque[0])))
			{
				
				if(!encontrada)
				{	
					posicion=5;
					posAux = posicion;
					datoAux =dato;
					bloqueAntiguo = nroBloqueAux;
					m_nroBloques.push_back(atoi(datoAux.substr(posicion,5).c_str()));
					datoAux.erase(posicion,TAMANIO_COD_PROD);
					posicion=0;
					//decremento el nro de regitros que tiene el nodo
					//esto lo hago por si no hay otro bloque para leer
					//datoAux[0]--; 
					encontrada=true;
				}


				nroBloqueAux = string2TipoDato(dato.substr(1,TAMANIO_COD_PROD));
				archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
				archivo.read(bloque,TAMANIO_LISTA_COD);
				if(((TIPO_DATO)(bloque[0])>1 && encontrada))
				{
					dato="";
					dato.append(bloque);
					//se lo cargo al bloque anterios
					insertarOrdenado(datoAux,dato.substr(5,TAMANIO_COD_PROD));
					//borro el nro de bloque del nuevo bloque porque lo agregue en el antiguo
					dato.erase(5,TAMANIO_COD_PROD);
					strncpy(bloque,datoAux.c_str(),TAMANIO_LISTA_COD);
					//escribo el bloque anterior
					archivo.seekp(TAMANIO_LISTA_COD*bloqueAntiguo,ios::beg);
					archivo.write(bloque,TAMANIO_LISTA_COD);		
					datoAux =dato;
					bloqueAntiguo = nroBloqueAux;
				}
				//dato="";
				++cantBloquesRecorridos;
			}//fin del while
			if(encontrada)
			{//quiere decir que se borro un registro

				strncpy(bloque,datoAux.c_str(),TAMANIO_LISTA_COD);
				bloque[0]--; //porque perdio un registro
				//escribo el bloque anterior
				nroBloqueAux = bloqueAntiguo;
			}	
			else//no entro al while porque el bloque que le sigue al vector no tiene la cantidad maxima de nro de bloques
			{
//					dato.erase(5,TAMANIO_COD_PROD);
//					strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
					if(cantBloquesRecorridos==0)
					{
						if(((TIPO_DATO)bloque[0]) == 1)
						{
							//m_indice--;
							for(int i=0;i<(m_indice-1);i++)
								cout<<"muestro el vector"<<m_nroBloques[i]<<endl;
							m_nroBloques.erase(m_nroBloques.begin() + (m_indice - 2));							
							m_nroBloques.push_back(string2TipoDato(dato.substr(5,TAMANIO_COD_PROD)));
							std::sort(m_nroBloques.begin(),m_nroBloques.end());
							for(int i=0;i<(m_indice-1);i++)
								cout<<"muestro el vector"<<m_nroBloques[i]<<endl;
						}
						else
						{
						}
						bloque[0]--;
					}
					else
						cout<<"TENDRIA QUE ENCONTRARLO !!!!!!!!!!!!??????"<<endl;
					dato.erase(5,TAMANIO_COD_PROD);
					strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);

			}
			archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
			archivo.write(bloque,TAMANIO_LISTA_COD);		

			m_indice--;
			
		}
		else//no encontre la clave en el vector de nro de bloques
		{
			TIPO_DATO cantMaxCod,nroBloqueAux,bloqueAntiguo;
			int posicion,posAux,cantDigitos,cantBloquesRecorridos=0;
			string dato="",strNroBloqueIn="",datoAux="";
			char bloque[TAMANIO_LISTA_COD]={};
			strNroBloqueIn = itoa((int)nroBloqueIn);
			//el ultimo registro se guarda para concatenar los distintos bloques para formar la lista de codigos
			cantMaxCod = (TAMANIO_LISTA_COD-1)/TAMANIO_COD_PROD ;//cant max de codigos en el bloque de lista
			nroBloqueAux = m_nroBloques[m_indice-1];
			archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
			archivo.read(bloque,TAMANIO_LISTA_COD);		
			dato.append(bloque);
			/*comienzo a leer todos los bloques*/
			while(cantMaxCod==((TIPO_DATO)(bloque[0])))
			{
				
				if(!encontrada)
					posicion = (int)dato.find(strNroBloqueIn);	
				/*aunque encuentre el nro de bloque tengo que seguir recorriendo los bloques
				para completar el registro que estoy borrando en el nodo que lo encontre.*/
				if(posicion>0)
				{	
					cantDigitos = (int)log10((double)nroBloqueIn) + 1;
					while(cantDigitos<5)
					{
						--posicion;
						++cantDigitos;
					}
					posAux = posicion;
					datoAux =dato;
					bloqueAntiguo = nroBloqueAux;
					datoAux.erase(posicion,TAMANIO_COD_PROD);
					posicion=0;
					//decremento el nro de regitros que tiene el nodo
					//esto lo hago por si no hay otro bloque para leer
					//datoAux[0]--; 
					encontrada=true;
				}


				nroBloqueAux = string2TipoDato(dato.substr(1,TAMANIO_COD_PROD));
				archivo.seekg(TAMANIO_LISTA_COD*nroBloqueAux ,ios::beg);
				archivo.read(bloque,TAMANIO_LISTA_COD);
				if(((TIPO_DATO)(bloque[0])>1 && encontrada))
				{
					dato="";
					dato.append(bloque);
					//se lo cargo al bloque anterios
					insertarOrdenado(datoAux,dato.substr(5,TAMANIO_COD_PROD));
					//borro el nro de bloque del nuevo bloque porque lo agregue en el antiguo
					dato.erase(5,TAMANIO_COD_PROD);
					strncpy(bloque,datoAux.c_str(),TAMANIO_LISTA_COD);
					//escribo el bloque anterior
					archivo.seekp(TAMANIO_LISTA_COD*bloqueAntiguo,ios::beg);
					archivo.write(bloque,TAMANIO_LISTA_COD);		
					datoAux =dato;
					bloqueAntiguo = nroBloqueAux;
				}
				//dato="";
				++cantBloquesRecorridos;
			}//fin del while
			if(encontrada)
			{//quiere decir que se borro un registro

				strncpy(bloque,datoAux.c_str(),TAMANIO_LISTA_COD);
				bloque[0]--; //porque perdio un registro
				//escribo el bloque anterior
				nroBloqueAux = bloqueAntiguo;
			}	
			else//no entro al while porque el bloque que le sigue al vector no tiene la cantidad maxima de nro de bloques
			{
					dato.erase(5,TAMANIO_COD_PROD);
					strncpy(bloque,dato.c_str(),TAMANIO_LISTA_COD);
					/*no lo encontro y solo se quedo en el primer bloque*/
					if(cantBloquesRecorridos==0)
					{
						if(((TIPO_DATO)bloque[0]) == 1)
						{
							m_nroBloques.erase(m_nroBloques.begin() + (m_indice - 1));
							m_indice--;
						}
						bloque[0]--;
					}
					else
						cout<<"TENDRIA QUE ENCONTRARLO !!!!!!!!!!!!??????"<<endl;

			}
			archivo.seekp(TAMANIO_LISTA_COD*nroBloqueAux,ios::beg);
			archivo.write(bloque,TAMANIO_LISTA_COD);		

		}
	}
	return false;
}
void CClaveEspacioLibre::insertarOrdenado(string dato, string nroBloque)
{
}
void CClaveEspacioLibre::ordenar()
{
	vector<TIPO_DATO>				vectorClaves;

	if(m_nroBloques[0]>m_nroBloques[1])
	{
		for(int i=0;i<m_indice ;i++)
			vectorClaves.push_back(m_nroBloques[(m_indice -1)-i]);

	//	for(int i=0;i<m_indice ;i++)
	//		cout<<"elemento del vector : "<<vectorClaves[i]<<endl;

		for(int i=0;i<m_indice ;i++)
			m_nroBloques[i]=vectorClaves[i];
	}
//	for(int i=0;i<m_indice ;i++)
//		cout<<"elemento del vector : "<<m_nroBloques[i]<<endl;
}
#endif //__CLAVEESPACIOLIBRE_H__

